{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log\n",
    "def calcShannonEnt(dataSet):\n",
    "    numEntries=len(dataSet)\n",
    "    labelCounts={}\n",
    "    for featVec in dataSet:\n",
    "        currentLabel=featVec[-1]\n",
    "        if currentLabel not in labelCounts.keys():\n",
    "            labelCounts[currentLabel]=0\n",
    "        labelCounts[currentLabel]+=1\n",
    "    shannonEnt=0.0\n",
    "    for key in labelCounts:\n",
    "        prob=float(labelCounts[key])/numEntries\n",
    "        shannonEnt-=prob*log(prob,2)\n",
    "    return shannonEnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['no surfacing', 'flippers']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def creatDataSet():\n",
    "    dataSet=[\n",
    "        [1,1,'yes'],\n",
    "        [1,1,'yes'],\n",
    "        [1,0,'no'],\n",
    "        [0,1,'no'],\n",
    "        [0,1,'no']\n",
    "    ]\n",
    "    labels=['no surfacing','flippers']\n",
    "    return dataSet,labels\n",
    "myDat,labels=creatDataSet()\n",
    "print(labels)\n",
    "myDat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9709505944546686"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calcShannonEnt(myDat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def splitDataSet(dataSet,axis,value):\n",
    "    retDataSet=[]\n",
    "    for featVec in dataSet:\n",
    "        if featVec[axis]==value:\n",
    "            reducedFeatVec=featVec[:axis]\n",
    "            reducedFeatVec.extend(featVec[axis+1:])\n",
    "            retDataSet.append(reducedFeatVec)\n",
    "    return retDataSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 'no'], [1, 'no']]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "splitDataSet(myDat,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 1, 0, 0]\n",
      "[1, 1, 0, 1, 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def chooseBestFeatureToSplit(dataSet):\n",
    "    numFeatures=len(dataSet[0])-1\n",
    "    baseEntropy=calcShannonEnt(dataSet)\n",
    "    bestInfoGain=0.0;bestFeature=-1\n",
    "    for i in range(numFeatures):\n",
    "        featList=[example[i] for example in dataSet]\n",
    "        print(featList)\n",
    "        uniqueVals=set(featList)\n",
    "        newEntropy=0.0\n",
    "        for value in uniqueVals:\n",
    "            subDataSet=splitDataSet(dataSet,i,value)\n",
    "            prob=len(subDataSet)/float(len(dataSet))\n",
    "            newEntropy+=prob*calcShannonEnt(subDataSet)\n",
    "        infoGain=baseEntropy-newEntropy\n",
    "        if infoGain>bestInfoGain:\n",
    "            bestInfoGain=infoGain\n",
    "            bestFeature=i\n",
    "    return bestFeature\n",
    "chooseBestFeatureToSplit(myDat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def majorityCnt(classList):\n",
    "    classCount={}\n",
    "    for vote in classList:\n",
    "        if vote not in classCount.keys():\n",
    "            classCount[vote]=0\n",
    "        classCount[vote]+=1\n",
    "    sortedClassCount=sorted(classCount.iteritems(),\\\n",
    "                           key=operator.itemgetter(1),reverse=True)\n",
    "    return sortedClassCount[0][0]\n",
    "# classList=[example[-1] for example in myDat]\n",
    "# majorityCnt(classList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myDat,labels=creatDataSet()\n",
    "def createTree(dataSet,labels):\n",
    "    classList=[example[-1] for example in dataSet]\n",
    "    if classList.count(classList[0])==len(classList):\n",
    "        return classList[0]\n",
    "    if len(dataSet[0])==1:\n",
    "        return majorityCnt(classList)\n",
    "    bestFeat=chooseBestFeatureToSplit(dataSet)\n",
    "   \n",
    "    bestFeatLabel=labels[bestFeat]\n",
    "    myTree={bestFeatLabel:{}}\n",
    "    del(labels[bestFeat])\n",
    "    featValues=[example[bestFeat] for example in dataSet]\n",
    "    uniqueVals=set(featValues)\n",
    "    for value in uniqueVals:\n",
    "        subLabels=labels[:]\n",
    "        myTree[bestFeatLabel][value]=createTree(splitDataSet(dataSet,bestFeat,value),subLabels)\n",
    "    return myTree\n",
    "myTree=createTree(myDat,labels)\n",
    "myTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "decisionNode=dict(boxstyle='sawtooth',fc='0.8')\n",
    "leafNode=dict(boxstyle='round4',fc='0.8')\n",
    "arrow_args=dict(arrowstyle='<-')\n",
    "def plotNode(nodeTxt,centerPt,parentPt,nodeType):\n",
    "    createPlot.axl.annotate(nodeTxt,xy=parentPt,xycoords='axes fraction',xytext=centerPt,textcoords='axes fraction',\\\n",
    "                           va='center',ha='center',bbox=nodeType,arrowprops=arrow_args)\n",
    "def createPlot():\n",
    "    fig=plt.figure(1,facecolor='w')\n",
    "    fig.clf()\n",
    "    createPlot.axl=plt.subplot(111,frameon=False)\n",
    "    plotNode(U'j',(0.5,0.1),(0.1,0.5),decisionNode)\n",
    "    plotNode(U'y',(0.8,0.1),(0.3,0.8),leafNode)\n",
    "    plt.show()\n",
    "createPlot()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "create by 2018-05-18\n",
    "@author: Shiyipaisizuo\n",
    "\"\"\"\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "# 定义文本框和箭头格式\n",
    "decisionnode = dict(boxstyle='sawtooth', fc='0.8')\n",
    "leafnode = dict(boxstyle='round4', fc='0.8')\n",
    "arrow_args = dict(arrowstyle='<-')\n",
    "\n",
    "\n",
    "# 绘制带箭头的注释\n",
    "def plot_node(nodetxt, centerpt, parentpt, nodetype):\n",
    "    create_plot.ax1.annotate(nodetxt, xy=parentpt, xycoords='axes fraction',\n",
    "                            xytext=centerpt, textcoords='axes fraction',\n",
    "                            va=\"center\", ha=\"center\", bbox=nodetype, arrowprops=arrow_args)\n",
    "\n",
    "# 获取叶子节点的数目\n",
    "def get_num_leafs(mytree):\n",
    "    numleafs = 0\n",
    "    firststr = list(mytree.keys())[0]\n",
    "    seconddict = mytree[firststr]\n",
    "\n",
    "    # 测试节点数据是否为字典\n",
    "    for key in seconddict.keys():\n",
    "        if type(seconddict[key]).__name__ == 'dict':\n",
    "            numleafs += get_num_leafs(seconddict[key])\n",
    "        else:\n",
    "            numleafs += 1\n",
    "    return numleafs\n",
    "\n",
    "\n",
    "# 获取决策树的层数\n",
    "def get_tree_depth(mytree):\n",
    "    maxdepth = 0\n",
    "    firststr = list(mytree.keys())[0]\n",
    "    seconddict = mytree[firststr]\n",
    "\n",
    "    # 测试数据是否为字典\n",
    "    for key in seconddict.keys():\n",
    "        if type(seconddict[key]).__name__ == 'dict':\n",
    "            thisdepth = 1 + get_tree_depth(seconddict[key])\n",
    "        else:\n",
    "            thisdepth = 1\n",
    "        if thisdepth > maxdepth: maxdepth = thisdepth\n",
    "    return maxdepth\n",
    "\n",
    "\n",
    "# 预先储存树的信息，避免每次都要从数据中创建树的麻烦\n",
    "def retrieve_tree(i):\n",
    "    listoftrees = [{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}},\n",
    "                   {'no surfacing': {0: 'no', 1: {'flippers': {0: {'head': {0: 'no', 1: 'yes'}}, 1: 'no'}}}}\n",
    "                   ]\n",
    "    return listoftrees[i]\n",
    "\n",
    "\n",
    "# 在父节点中填充文本的信息\n",
    "def plot_mid_text(cntrpt, parentpt, txtstring):\n",
    "    xmid = (parentpt[0] - cntrpt[0]) / 2.0 + cntrpt[0]\n",
    "    ymid = (parentpt[1] - cntrpt[1]) / 2.0 + cntrpt[1]\n",
    "    create_plot.ax1.text(xmid, ymid, txtstring, va=\"center\", ha=\"center\", rotation=30)\n",
    "\n",
    "\n",
    "# 绘制树\n",
    "def plot_tree(mytree, parentpt, nodetxt):\n",
    "\n",
    "    # 计算树的宽和高\n",
    "    numleafs = get_num_leafs(mytree)\n",
    "    depth = get_tree_depth(mytree)\n",
    "    firststr =list(mytree.keys())[0]\n",
    "    cntrpt = (plot_tree.xoff + (1.0 + float(numleafs)) / 2.0 / plot_tree.totalw, plot_tree.yoff)\n",
    "    plot_mid_text(cntrpt, parentpt, nodetxt)\n",
    "    plot_node(firststr, cntrpt, parentpt, decisionnode)\n",
    "    seconddict = mytree[firststr]\n",
    "    plot_tree.yoff = plot_tree.yoff - 1.0 / plot_tree.totald\n",
    "\n",
    "    # 测试数据是否为字典\n",
    "    for key in seconddict.keys():\n",
    "        if type(seconddict[key]).__name__ == 'dict':\n",
    "            plot_tree(seconddict[key], cntrpt, str(key))\n",
    "\n",
    "        else:  # 它是叶子节点打印叶子节点\n",
    "            plot_tree.xoff = plot_tree.xoff + 1.0 / plot_tree.totalw\n",
    "            plot_node(seconddict[key], (plot_tree.xoff, plot_tree.yoff), cntrpt, leafnode)\n",
    "            plot_mid_text((plot_tree.xoff, plot_tree.yoff), cntrpt, str(key))\n",
    "    plot_tree.yoff = plot_tree.yoff + 1.0 / plot_tree.totald\n",
    "\n",
    "\n",
    "# 如果你得到了一个dictonary，你知道它是一棵树，第一个元素将是另一个法令。\n",
    "def create_plot(intree):\n",
    "    fig = plt.figure(1, facecolor='white')\n",
    "    fig.clf()\n",
    "    axprops = dict(xticks=[], yticks=[])\n",
    "    create_plot.ax1 = plt.subplot(111, frameon=False, **axprops)  # no ticks\n",
    "    plot_tree.totalw = float(get_num_leafs(intree))\n",
    "    plot_tree.totald = float(get_tree_depth(intree))\n",
    "    plot_tree.xoff = -0.5 / plot_tree.totalw;\n",
    "    plot_tree.yoff = 1.0;\n",
    "    plot_tree(intree, (0.5, 1.0), '')\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myDat,labels=creatDataSet()\n",
    "myTree=retrieve_tree(0)\n",
    "myTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classify(inputTree,featLabels,testVec):\n",
    "    firstStr=list(inputTree.keys())[0]\n",
    "    secondDict=inputTree[firstStr]\n",
    "    featIndex=featLabels.index(firstStr)\n",
    "    for key in secondDict.keys():\n",
    "        if testVec[featIndex]==key:\n",
    "            if type(secondDict[key]).__name__=='dict':\n",
    "                classLabel=classify(secondDict[key],featLabels,testVec)\n",
    "            else:\n",
    "                classLabel=secondDict[key]\n",
    "    return classLabel\n",
    "myDat,labels=creatDataSet()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'no'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myDat,labels=creatDataSet()\n",
    "myTree=retrieve_tree(0)\n",
    "classify(myTree,labels,[1,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'tearRate': {'normal': {'astigmatic': {'no': {'age': {'presbyopic': {'prescript': {'hyper': 'soft',\n",
       "        'myope': 'no lenses'}},\n",
       "      'pre': 'soft',\n",
       "      'young': 'soft'}},\n",
       "    'yes': {'prescript': {'hyper': {'age': {'presbyopic': 'no lenses',\n",
       "        'pre': 'no lenses',\n",
       "        'young': 'hard'}},\n",
       "      'myope': 'hard'}}}},\n",
       "  'reduced': 'no lenses'}}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fr=open('lenses.txt')\n",
    "lenses=[inst.strip().split('\\t') for inst in fr.readlines()]\n",
    "lensesLabels=['age','prescript','astigmatic','tearRate']\n",
    "lensesTree=createTree(lenses,lensesLabels)\n",
    "lensesTree\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "create_plot(lensesTree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
